home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Environments / PowerMacOberon feb96 / Source / OpenElems.Mod (.txt) < prev    next >
Encoding:
Oberon Text  |  1995-12-01  |  6.2 KB  |  173 lines  |  [TEXT/.Ob4]
  1. Syntax10.Scn.Fnt
  2. Syntax10b.Scn.Fnt
  3. Syntax10i.Scn.Fnt
  4. InfoElems
  5. Alloc
  6. Syntax10.Scn.Fnt
  7. StampElems
  8. Alloc
  9. 1 Dec 95
  10. "Title": OpenElems
  11. "Author": Christoph Steindl (CS)
  12. "Abstract": OpenElems perform a generic open command on the selected item. Depending on the suffix of the
  13.     entry different commands are called. The items are collected automatically from the current directory.
  14. "Keywords": Opening files
  15. "Version": 1.0
  16. "From":  22.05.95 15:39:15
  17. "Until": 
  18. "Changes": no changes
  19. "Hints": You can insert new suffix mappings by calling OpenElems.Add pattern command, can also be used to override
  20.     the default mapping, i.e. OpenElems.Add *.Text MyEdit.Open will cause *.Text files to be opened with MyEdit.
  21.     The predefined mappings are taken from the file Dir.Menu.Text. The syntax for entries in Dir.Menu.Text is described
  22.     in Dir.Text.
  23. MODULE OpenElems;    (** CS 
  24.  Standard mapping of patterns to commands are taken from Dir.Menu.Text *)
  25. IMPORT Viewers, Texts, TextFrames, Oberon, PopupElems, Directories, Display, Strings, In;
  26.     OpenElem* = POINTER TO OpenElemDesc;
  27.     OpenElemDesc* = RECORD (PopupElems.ElemDesc)
  28.     END;
  29.     AutoDirElem* = POINTER TO AutoDirElemDesc;
  30.     AutoDirElemDesc* = RECORD (OpenElemDesc)
  31.     END;
  32.     Str64 = ARRAY 64 OF CHAR;
  33.     Entry = POINTER TO EntryDesc;
  34.     EntryDesc = RECORD
  35.         pat: ARRAY 10 OF CHAR;
  36.         cmd: Str64;
  37.         next: Entry
  38.     END;
  39.     w: Texts.Writer;
  40.     map: Entry;
  41.     cnt: INTEGER;
  42.     pattern: ARRAY 32 OF CHAR;
  43. PROCEDURE ReadName (t: Texts.Text; pos: LONGINT; VAR name: ARRAY OF CHAR);
  44.     VAR r: Texts.Reader; ch: CHAR; i: INTEGER;
  45. BEGIN
  46.     Texts.OpenReader(r, t, pos); Texts.Read(r, ch); i := 0;
  47.     IF ch = '"' THEN Texts.Read(r, ch);
  48.         WHILE ~r.eot & (ch # '"') DO name[i] := ch; INC(i); Texts.Read(r, ch) END
  49.     ELSE
  50.         WHILE ~r.eot & (ch > " ") DO name[i] := ch; INC(i); Texts.Read(r, ch) END
  51.     END;
  52.     name[i] := 0X
  53. END ReadName;
  54. PROCEDURE Lookup(VAR name, cmd: ARRAY OF CHAR);
  55.     VAR e: Entry;
  56. BEGIN
  57.     e := map; WHILE (e # NIL) & ~Strings.Match(name, e.pat) DO e := e.next END;
  58.     IF e # NIL THEN COPY(e.cmd, cmd) ELSE COPY("Edit.Open", cmd) END
  59. END Lookup;
  60. PROCEDURE Exec (e: OpenElem; f: Display.Frame; pos: LONGINT);
  61.     VAR m: TextFrames.UpdateMsg; res: INTEGER; name: ARRAY 256 OF CHAR;
  62.         par: Oberon.ParList; cmd: ARRAY 64 OF CHAR; dir: Directories.Directory;
  63. BEGIN
  64.     ReadName(e.menu, pos, name);
  65.     dir := Directories.This(name);
  66.     IF dir # NIL THEN
  67.         Directories.Change(dir.path)
  68.     ELSE
  69.         Lookup(name, cmd);
  70.         NEW(par); par.frame := f; par.text := e.menu; par.pos := pos;
  71.         Oberon.Call(cmd, par, FALSE, res);
  72.         IF res # 0 THEN Texts.WriteString(w, " -- failed"); Texts.WriteLn(w); Texts.Append(Oberon.Log, w.buf) END
  73. END Exec;
  74. PROCEDURE Handle* (e: Texts.Elem; VAR m: Texts.ElemMsg);
  75.     VAR e1: OpenElem;
  76. BEGIN
  77.     WITH e: OpenElem DO
  78.         WITH
  79.             m: Texts.CopyMsg DO
  80.                 IF m.e = NIL THEN NEW (e1); m.e := e1 END;
  81.                 PopupElems.Handle(e, m)
  82.         |  m: Texts.IdentifyMsg DO
  83.                 m.mod := "OpenElems"; m.proc := "Alloc"
  84.         |  m: PopupElems.ExecMsg DO Exec(e, m.frame, m.pos)
  85.         ELSE PopupElems.Handle(e, m)
  86.         END
  87. END Handle;
  88. PROCEDURE Alloc*;
  89.     VAR e: OpenElem;
  90. BEGIN
  91.     NEW(e); e.handle := Handle; Texts.new := e
  92. END Alloc;
  93. PROCEDURE Insert*;
  94.     VAR e: OpenElem; insert: TextFrames.InsertElemMsg; s: Texts.Scanner;
  95. BEGIN
  96.     NEW(e); e.handle := Handle; e.small := TRUE; 
  97.     Texts.OpenScanner(s, Oberon.Par.text, Oberon.Par.pos); Texts.Scan(s);
  98.     IF ~(s.class IN {Texts.Name, Texts.String}) THEN s.s := "OpenElem" END;
  99.     COPY(s.s, e.name);
  100.     e.menu := TextFrames.Text(""); PopupElems.MeasureMenu(e);
  101.     insert.e := e; Viewers.Broadcast(insert)
  102. END Insert;
  103. PROCEDURE AddEntry (pattern, cmd: ARRAY OF CHAR);
  104.     VAR e: Entry;
  105. BEGIN
  106.     NEW(e);
  107.     COPY(pattern, e.pat); COPY(cmd, e.cmd);
  108.     IF (e.pat # "") & (e.cmd # "") THEN
  109.         e.next := map; map := e
  110. END AddEntry;
  111. PROCEDURE Add*; (* pattern command *)
  112.     VAR pattern, cmd: Str64;
  113. BEGIN
  114.     In.Open; In.Name(pattern); In.Name(cmd);
  115.     AddEntry(pattern, cmd)
  116. END Add;
  117. PROCEDURE ListProc (d: Directories.Directory; name: ARRAY OF CHAR; isDir: BOOLEAN; VAR continue: BOOLEAN);
  118. BEGIN 
  119.     IF Strings.Match(name, pattern) OR isDir THEN Texts.WriteString (w, name); Texts.WriteLn (w); INC(cnt) END
  120. END ListProc;
  121. PROCEDURE CollectFiles (e: OpenElem);
  122. BEGIN
  123.     e.menu := TextFrames.Text(""); cnt := 0; COPY(e.name, pattern);
  124.     Directories.Enumerate(Directories.Current(), ListProc);
  125.     IF cnt = 1 THEN Texts.WriteLn(w) END; (* prohibit AutoDirElems that do not pop up because they only contain one item *)
  126.     IF w.buf.len = 0 THEN Texts.WriteString (w, "no files found"); Texts.WriteLn (w); Texts.WriteLn (w) END;
  127.     Texts.Append(e.menu, w.buf); PopupElems.MeasureMenu(e)
  128. END CollectFiles;
  129. PROCEDURE HandleAutoDir* (e: Texts.Elem; VAR m: Texts.ElemMsg);
  130.     VAR e1: AutoDirElem;
  131. BEGIN
  132.     WITH e: AutoDirElem DO
  133.         WITH m: Texts.CopyMsg DO
  134.                 IF m.e = NIL THEN NEW (e1); m.e := e1 END;
  135.                 Handle(e, m)
  136.         |  m: Texts.IdentifyMsg DO
  137.                 m.mod := "OpenElems"; m.proc := "AllocAutoDir"
  138.         |  m: TextFrames.TrackMsg DO
  139.                 IF 1 IN m.keys THEN CollectFiles (e); Handle (e, m) END
  140.         ELSE Handle(e, m)
  141.         END
  142. END HandleAutoDir;
  143. PROCEDURE AllocAutoDir*;
  144.     VAR e: AutoDirElem;
  145. BEGIN
  146.     NEW(e); e.handle := HandleAutoDir; Texts.new := e
  147. END AllocAutoDir;
  148. PROCEDURE InsertAutoDir*;
  149.     VAR e: AutoDirElem; insert: TextFrames.InsertElemMsg;
  150. BEGIN
  151.     NEW(e); e.handle := HandleAutoDir; e.small := TRUE; e.name := "*";
  152.     e.menu := TextFrames.Text(""); PopupElems.MeasureMenu(e);
  153.     insert.e := e; Viewers.Broadcast(insert)
  154. END InsertAutoDir;
  155. PROCEDURE NoNotify (t: Texts.Text; op: INTEGER; beg, end: LONGINT);
  156. END NoNotify;
  157. PROCEDURE Init;
  158.     VAR cmd, pattern: Str64; scratch: Texts.Text; s: Texts.Scanner;
  159. BEGIN
  160.     NEW(scratch); Texts.Open(scratch, "Dir.Menu.Text"); scratch.notify := NoNotify;
  161.     Texts.OpenScanner(s, scratch, 0); 
  162.     REPEAT Texts.Scan(s) UNTIL s.eot OR (s.line # 0);
  163.     WHILE s.class = Texts.String DO
  164.         COPY(s.s, pattern); Texts.Scan(s);
  165.         IF s.class IN {Texts.Name, Texts.String} THEN COPY(s.s, cmd); Texts.Scan(s) END;
  166.         AddEntry(pattern, cmd)
  167. END Init;
  168. BEGIN
  169.     Texts.OpenWriter(w);
  170.     Init
  171. END OpenElems.Insert 
  172. OpenElems.InsertAutoDir
  173.